#!/bin/bash

# /***************/
# /** Funciones **/
# /***************/

########################################################################################
# Funcion emitir
# Emite en Log de GrabarParqueT el mensaje informativo que se desea.
emitir() {
  ./LoguearT "GrabarParqueT" "I" "$1"
  
}
########################################################################################
# Funcion emitirError
# Emite por salida estandar y escribe Log de GrabarParqueT el error que se desea.
emitirError() {
  echo "$1"
  ./LoguearT "GrabarParqueT" "E" "$1"
 
}
########################################################################################
# Funcion mover
# Encargado de llamar al comando mover.
mover() {  
  ./MoverT "$1" "$2" "GrabarParqueT" 
}
########################################################################################
# Funcion validarSintaxis 
# Valida sintaxis de un registro del archivo
# Parametros:
#	$1 - customerId
#	$2 - operationDate
#	$3 - planId
#	$4 - serviceId
#	$5 - serviceIsRequired
#	$6 - itemId
validarSintaxis() {
  if [ "$#" -gt 6 ]
  then
    detalleError="Error en registro $nroLinea del archivo, mas cantidad de campos de los esperados, sera ignorado"
    return 1  
  fi
  if [ "$#" -lt 6 ]
  then
    detalleError="Error en registro $nroLinea del archivo, menos cantidad campos de los esperados, sera ignorado"
    return 2
  fi
  
  testSintaxis=`echo "$@" | grep "^[0-9]\{1,\} [0-9]\{2\}/[0-9]\{2\}/[0-9]\{4\} [0-9]\{1,\} [0-9]\{1,\} [Y,N] [0-9]\{1,\}$"`
  if [ -z "$testSintaxis" ]
  then
    detalleError="Error en registro $nroLinea del archivo, sintaxis incorrecta, sera ignorado"
    return 3    
  else
    customerIdTmp=$1
    operationDateTmp=$2
    planIdTmp=$3
    serviceIdTmp=$4
    serviceIsRequiredTmp=$5
    itemIdTmp=$6
    return 0
  fi  
}
########################################################################################
# Funcion validarCliente 
# Valida que un id de cliente exista en el maestro de los mismos.
# Parametros:
#	$1 - customerId
validarCliente() {
  datosCliente=""  
  if [ $# -ne 1 ]
  then
    return 1  
  else
    datosCliente=`grep "^$1;.*;.*;.*;.*;.*;.*$" "$MAEDIR/cli.mae"`
    
    if [ "$datosCliente" == "" ]
    then
      return 2
    else
      return 0
    fi
  fi
}
########################################################################################
# Funcion validarProducto 
# Valida que un producto exista en el maestro de los mismos.
# Parametros:
#	$1 - planId
#	$2 - serviceId
#	$3 - itemId
#	$4 - serviceIsRequired
validarProducto() {
  datosProducto=""  
  if [ $# -ne 4 ]
  then
    return 1  
  else
    datosProducto=`grep "^.*,.*,$1,.*,$2,.*,$4,$3,.*$" "$MAEDIR/prod.mae"`
    
    if [ "$datosProducto" == "" ]
    then
      return 2
    else
      if [ "$4" == "Y" ] 
      then
        productTypeName=`echo "$datosProducto" | cut -f 2 -d","`
	itemNameCab=`echo "$datosProducto" | cut -f 9 -d","`
      else
        productTypeName=`echo "$datosProducto" | cut -f 2 -d","`
	itemNameDet=`echo "$datosProducto" | cut -f 9 -d","`
      fi
      return 0
    fi
  fi
}
########################################################################################
# Funcion validarFecha 
# Valida que la fecha de un registro se correcta, pertenezca al año corriente y sea menor a la actual.
# Parametros:
#	$1 - fecha
validarFecha() {
  fechaActual=""  
  testFecha=""
  if [ $# -ne 1 ]
  then
    return 1  
  else
    fechaValidar=`echo $1 | sed "s/^\([0-9]\{2\}\)\/\([0-9]\{2\}\)\/\([0-9]\{4\}\)$/\3\2\1/"`
    fechaActual=`date +%Y%m%d`
    testFecha=`date -d "$fechaValidar" 2> /dev/null`
    if [ "$testFecha" == "" ]
    then
      detalleError="Error en datos del bloque, fecha invalida"
      return 2
    else
      anioValidar=`echo $fechaValidar | cut -c1-4`
      anioActual=`echo $fechaActual | cut -c1-4`      
      if [ $anioActual -ne $anioValidar ]
      then 
        detalleError="Error en datos del bloque, año solicitado no es el corriente"
        return 3
      else
        if [ "$fechaValidar" -gt "$fechaActual" ]
        then
          detalleError="Error en datos del bloque, fecha superior a la actual"
          return 4
        else          
          return 0          
        fi        
      fi      
    fi
  fi
}

########################################################################################
# Funcion validarBloque 
# Valida que el bloque este completo y formado como corresponde, exista el cliente, producto y la fecha sea correcta.
validarBloque() {
  IFSFor=$IFS
  IFS=$IFSAnterior
  valueReturn=0
  if [ "$cantCabeceras" -ne 0 -o "$cantDetalles" -ne 0 ]
  then
    if [ "$cantCabeceras" -eq 0 ]
    then
      detalleError="Bloque incompleto, falta el registro cabecera correspondiente"      
      valueReturn=1
    else
      if [ "$cantDetalles" -eq 0 ]
      then
        detalleError="Bloque incompleto, falta el registro detalle correspondiente"
        valueReturn=2
      else
        if [ "$cantCabeceras" -gt 1 ]
        then
          detalleError="Bloque erroneo, mas de un registro cabecera en el mismo"
          valueReturn=3
        else
          if [ "$cantDetalles" -gt 1 ]
          then
            detalleError="Bloque erroneo, mas de un registro detalle en el mismo"
            valueReturn=4
          else
            validarCliente `echo "$customerId"`
            if [ "$?" -ne 0 ]
            then      
              detalleError="Error en datos del bloque, cliente inexistente en el archivo maestro"
              valueReturn=5
            else                
              validarFecha `echo "$operationDate"`
              if [ "$?" -ne 0 ]
              then                              
                valueReturn=6
              else
                validarProducto `echo "$planId $serviceIdCab $itemIdCab Y"`
                if [ "$?" -ne 0 ]
                then      
                  detalleError="Error en datos del bloque, producto cabecera inexistente en el archivo maestro"
                  valueReturn=7
                else
                  validarProducto `echo "$planId $serviceIdDet $itemIdDet N"`
                  if [ "$?" -ne 0 ]
                  then      
                    detalleError="Error en datos del bloque, producto detalle inexistente en el archivo maestro"
                    valueReturn=8                  
                  fi
                fi                                         
              fi
            fi                
          fi
        fi
      fi
    fi          
  fi
  IFS=$IFSFor
  return $valueReturn
}

# /**********/
# /** Main **/
# /**********/

# /** Chequeo de que no haya un GrabarParqueT corriendo **/

pidGrabarParqueT=`ps --no-heading -o pid -C "GrabarParqueT"`

if [ -z "$pidGrabarParqueT" ]
then
    emitirError "GrabarParqueT ya esta ejecucion con PID $pidGrabarParqueT."
    exit 1
fi

# /** Chequeo de que el ambiente este inicializado correctamente **/

if [ "$AMBIENTE_INICIALIZADO" != "Y" ] 
then
  emitirError "El ambiente no fue corrrectamente inicializado. Por favor ejecute IniciarT para realizarlo."
  exit 2
fi

# /** Inicio logueo de GrabarParqueT mostrando la cantidad de documentos a procesar **/

archRecibidos=`ls "$GRUPO/inst_recibidas"`
cantArchRecibidos=`ls "$GRUPO/inst_recibidas" | wc -l`
cantArchOrdenados=0
cantArchRechazados=0
totalBloquesLeidos=0
totalBloquesOk=0
totalBloquesError=0
totalRegistrosLeidos=0
totalRegistrosOk=0
totalRegistrosError=0

emitir "Inicio de GrabarParqueT - Se Procesaran $cantArchRecibidos Instalaciones Recibidas."

# /** Empiezo a recorrer las instalaciones recibidas que tengo en el directorio **/
for archInstalacion in $archRecibidos
do
  emitir "  Archivo de Instalacion a Procesar: $archInstalacion."
  emitir ""
  
  # /** Verifico que no haya un archivo de instalaciones ya procesado con ese nombre **/
  instYaFueProcesada=`ls $GRUPO/inst_procesadas | grep "^$archInstalacion" | wc -l`    
  if [ "$instYaFueProcesada" -ne 0 ]
  then
    # /** Mover el archivo a rechazados **/
    emitir "  Archivo de instalacion rechazado, ya fue procesado anteriormente."  
    mover "$GRUPO/inst_recibidas/$archInstalacion" "$RECHDIR"  
    cantArchRechazados=`echo "$cantArchRechazados + 1" | bc`
    continue
  fi
  
  # /** Ordeno el archivo de instalaciones y lo escribo en el directorio inst_ordenadas, pisando si hay uno igual **/
  sed "s/^\([0-9]\{1,\}\),\([0-9]\{2\}\)\/\([0-9]\{2\}\)\/\([0-9]\{4\}\),\([0-9]\{1,\}\),\([0-9]\{1,\}\),\([Y,N]\),\([0-9]\{1,\}\)$/\1,\2,\3,\4,\5,\6,\7,\8/" "$GRUPO/inst_recibidas/$archInstalacion" | sort -t',' -k1,1g -k4,4g -k3,3g -k2,2g -k5,5g -k7,7r | sed "s/^\([0-9]\{1,\}\),\([0-9]\{2\}\),\([0-9]\{2\}\),\([0-9]\{4\}\),\([0-9]\{1,\}\),\([0-9]\{1,\}\),\([Y,N]\),\([0-9]\{1,\}\)$/\1,\2\/\3\/\4,\5,\6,\7,\8/" > "$GRUPO/inst_ordenadas/$archInstalacion"  
  
  cantArchOrdenados=`echo "$cantArchOrdenados + 1" | bc`

  # /** Muevo el archivo de instalaciones a directorio inst_procesadas **/
  mover "$GRUPO/inst_recibidas/$archInstalacion" "$GRUPO/inst_procesadas"
  
  # /** Empiezo a recorrer y procesar el archivo de instalaciones ordenado **/
  emitir "    Procesando archivo $GRUPO/inst_ordenadas/$archInstalacion ."

  bloquesLeidos=0
  bloquesOk=0
  bloquesError=0
  nroLinea=1  
  lineasError=0
  cantCabeceras=0
  cantDetalles=0
  detalleError=""

  customerIdTmp=""
  operationDateTmp=""
  planIdTmp=""  
  serviceIdTmp=""
  serviceIsRequiredTmp=""
  itemIdTmp=""

  customerId=""
  operationDate=""
  planId=""  
  serviceIdCab=""
  itemIdCab=""
  serviceIdDet=""
  itemIdDet=""

  branchId=""
  productTypeName=""
  itemNameCab=""
  itemNameDet=""

	# /** Modifico IFS para recorrer **/
	IFSAnterior=$IFS
	IFS='
'
  
  # /** Comienzo a recorrer los registros del archivo **/
  for linea in `cat "$GRUPO/inst_ordenadas/$archInstalacion"`
  do      
    IFSFor=$IFS
    IFS=','
    
    # /** Valido los datos de la linea del archivo **/
    validarSintaxis `echo "$linea" | cut -f 1-7 -d","`    
    
    if [ "$?" -ne 0 ]
    then      
      # /** Si hubo error de sintaxis **/
      IFS=$IFSFor
      emitir "    $detalleError"
      fechaHoraActual=`date +%d/%m/%Y\ %H:%M`
      echo "$fechaHoraActual-$detalleError-$linea" >> "$GRUPO/inst_rechazadas/$archInstalacion"
      lineasError=`echo "$lineasError + 1" | bc`
    else
      # /** Si no hubo error de sintaxis **/      
      IFS=$IFSFor
      if [ "$customerId" == "$customerIdTmp" -a "$operationDate" == "$operationDateTmp" -a "$planId" == "$planIdTmp" ]
      then
        # /** Si obtuve otro registro del mismo bloque **/
        if [ "$serviceIsRequiredTmp" == "Y" ]
        then
          serviceIdCab=$serviceIdTmp
          itemIdCab=$itemIdTmp
          cantCabeceras=`echo $cantCabeceras + 1 | bc -l`          
        else
          serviceIdDet=$serviceIdTmp
          itemIdDet=$itemIdTmp
          cantDetalles=`echo $cantDetalles + 1 | bc -l`
        fi
      else
        # /** Obtuve un registro correspondiente a otro bloque o es el primer registro del archivo **/
	if [ "$customerId" != "" -a "$operationDate" != "" -a "$planId" != "" ]
        then          
          # /** Valido el bloque **/
          validarBloque        
        
          if [ "$?" -ne 0 ]
          then
	    # /** Hubo error en integridad bloque, obtengo el bloque completo y lo escribo en inst_rechazadas/instalacion **/
            bloqueCompleto=`grep "^$customerId,$operationDate,$planId,[0-9]\{1,\},[Y,N],[0-9]\{1,\}$" "$GRUPO/inst_ordenadas/$archInstalacion"`
            fechaHoraActual=`date +%d/%m/%Y\ %H:%M`

            for lineabloque in `echo "$bloqueCompleto" | cat`
            do
              echo "$fechaHoraActual-$detalleError-$lineabloque" >> "$GRUPO/inst_rechazadas/$archInstalacion"
              lineasError=`echo "$lineasError + 1" | bc`
            done

            bloquesError=`echo "$bloquesError + 1" | bc`
            emitir "    $detalleError, en linea $nroLinea"
	  else	
            # /** Bloque correcto, obtengo el nombre de la sucursal y envio a parque_instalado el registro que corresponde **/
            branchId=`echo "$archInstalacion" | cut -f1 -d"." | cut -f2 -d"-"`
            echo "$branchId,$customerId,$itemNameCab,$itemNameCab" >> "$GRUPO/parque_instalado/$productTypeName"
            
            bloquesOk=`echo "$bloquesOk + 1" | bc`
          fi           
          bloquesLeidos=`echo "$bloquesLeidos + 1" | bc`
        fi
        
        customerId=$customerIdTmp
        operationDate=$operationDateTmp
        planId=$planIdTmp

        if [ "$serviceIsRequiredTmp" == "Y" ]
        then
          serviceIdCab=$serviceIdTmp
          itemIdCab=$itemIdTmp
          cantCabeceras=1
          cantDetalles=0
        else
          serviceIdDet=$serviceIdTmp
          itemIdDet=$itemIdTmp
          cantCabeceras=0
          cantDetalles=1
        fi		  
      fi
    fi    
    nroLinea=`echo "$nroLinea + 1" | bc`
  done    
  # /** Corrijo IFS nuevamente **/
  IFS=$IFSAnterior 
  
  # /** Valido el ultimo bloque, si es que hay **/
  if [ "$customerId" != "" -a "$operationDate" != "" -a "$planId" != "" ]  
  then
    # /** Valido el bloque **/
    validarBloque
        
    if [ "$?" -ne 0 ]
    then
      # /** Hubo error en integridad bloque, obtengo el bloque completo y lo escribo en inst_rechazadas/instalacion **/
      bloqueCompleto=`grep "^$customerId,$operationDate,$planId,[0-9]\{1,\},[Y,N],[0-9]\{1,\}$" "$GRUPO/inst_ordenadas/$archInstalacion"`
      fechaHoraActual=`date +%d/%m/%Y\ %H:%M`

      for lineabloque in `echo "$bloqueCompleto" | cat`
      do
        echo "$fechaHoraActual-$detalleError-$lineabloque" >> "$GRUPO/inst_rechazadas/$archInstalacion"
        lineasError=`echo "$lineasError + 1" | bc`
      done
      
      bloquesError=`echo "$bloquesError + 1" | bc`
      emitir "    $detalleError, en linea $nroLinea"
    else
      # /** Bloque correcto, obtengo el nombre de la sucursal y envio a parque_instalado el registro que corresponde **/
      branchId=`echo "$archInstalacion" | cut -f1 -d"." | cut -f2 -d"-"`	
      echo "$branchId,$customerId,$itemNameCab,$itemNameCab" >> "$GRUPO/parque_instalado/$productTypeName"
      
      bloquesOk=`echo "$bloquesOk + 1" | bc`
    fi  
    bloquesLeidos=`echo "$bloquesLeidos + 1" | bc`
  fi

  nroLinea=`echo "$nroLinea - 1" | bc`

  totalBloquesLeidos=`echo "$totalBloquesLeidos + $bloquesLeidos" | bc`
  totalBloquesOk=`echo "$totalBloquesOk + $bloquesOk" | bc`
  totalBloquesError=`echo "$totalBloquesError + $bloquesError" | bc`

  totalRegistrosLeidos=`echo "$totalRegistrosLeidos + $nroLinea" | bc`
  totalRegistrosOk=`echo "$totalRegistrosOk + ($bloquesOk * 2)" | bc`
  totalRegistrosError=`echo "$totalRegistrosError + $lineasError" | bc`
  
  emitir ""
  emitir "    Se procesaron $nroLinea registros, de los cuales $lineasError tuvieron error."
  emitir "    Se encontraron $bloquesLeidos bloques, de los se grabaron $bloquesOk y se rechazon $bloquesError."
  emitir "  Fin de Proceso Archivo de Instalacion: $archInstalacion."
done

emitir ""
emitir "  Se leyeron $cantArchRecibidos archivos recibidos."
emitir "  Se ordenaron $cantArchOrdenados archivos."
emitir "  Se rechazaron $cantArchRechazados archivos."
emitir ""
emitir "  Se encontraron un total de $totalBloquesLeidos bloques."
emitir "  Se grabaron correctamente $totalBloquesOk bloques."
emitir "  Se encontraron $totalBloquesError bloques erroneos."
emitir ""
emitir "  Se encontraron un total de $totalRegistrosLeidos registros."
emitir "  Se grabaron correctamente $totalRegistrosOk bloques."
emitir "  Se encontraron $totalRegistrosError registros erroneos."
emitir "Fin de GrabarParqueT."
